#include <bits/stdc++.h>
using namespace std;
using ll = long long;
const int N = 500005, M = 4000005;
struct Edge {
    int u, v;
} e[M >> 1];
int n, m, q, a[N];
int head[N], to[M], nxt[M], cnt = 2;
int dfn[N], low[N], tot;
int stk[N], top;
int bel[N], ebcc_cnt;
int b[N], val[N];
int sum = 0;
void add(int u, int v) { to[cnt] = v, nxt[cnt] = head[u], head[u] = cnt++; }

void tarjan(int u, int in_edge) {
    dfn[u] = low[u] = ++tot;
    stk[++top] = u;
    for (int i = head[u]; i; i = nxt[i]) {
        if (i == (in_edge ^ 1)) continue;
        int v = to[i];
        if (!dfn[v]) {
            tarjan(v, i);
            low[u] = min(low[u], low[v]);
        } else {
            low[u] = min(low[u], dfn[v]);
        }
    }
    if (dfn[u] == low[u]) {
        ++ebcc_cnt;
        int s = 0;
        do {
            bel[stk[top]] = ebcc_cnt;
            s += a[stk[top]];
        } while (stk[top--] != u);
        b[ebcc_cnt] = s;
    }
}

std::vector<int> adj[N];
void add_edge(int u, int v) {
    adj[u].push_back(v);
    adj[v].push_back(u);
}
struct HLD {
    int n;
    std::vector<int> siz, dep, top, son, parent;
    explicit HLD(int n) : n(n), siz(n + 1), dep(n + 1), top(n + 1), son(n + 1), parent(n + 1) {}

    void dfs1(int u) {
        siz[u] = 1;
        dep[u] = dep[parent[u]] + 1;
        for (int v : adj[u]) {
            if (v == parent[u]) continue;
            parent[v] = u;
            dfs1(v);
            siz[u] += siz[v];
            if (siz[v] > siz[son[u]]) son[u] = v;
        }
    }

    void dfs2(int u, int up) {
        top[u] = up;
        if (son[u]) dfs2(son[u], up);
        for (int v : adj[u]) {
            if (v == parent[u] || v == son[u]) continue;
            dfs2(v, v);
        }
    }

    void work(int root = 1) {
        dfs1(root);
        dfs2(root, root);
    }

    int lca(int u, int v) const {
        while (top[u] != top[v]) {
            if (dep[top[u]] < dep[top[v]]) std::swap(u, v);
            u = parent[top[u]];
        }
        return dep[u] < dep[v] ? u : v;
    }

    int calc(int u, int v) const { return dep[u] + dep[v] - 2 * dep[lca(u, v)]; }

    int get_fa(int u) { return parent[u]; }
};
void dfs(int u, int f) {
    for (int v : adj[u]) {
        if (v == f) continue;
        dfs(v, u);
        val[u] += val[v];
    }
    if (val[u]) sum += b[u];
}
void fc() {
    std::cin >> n >> m;
    for (int i = 1; i <= n; i++) std::cin >> a[i];
    for (int i = 0; i < m; i++) {
        std::cin >> e[i].u >> e[i].v;
        add(e[i].u, e[i].v);
        add(e[i].v, e[i].u);
    }

    tarjan(1, 0);

    HLD hld(ebcc_cnt);
    for (int i = 0; i < m; i++) {
        int u = bel[e[i].u], v = bel[e[i].v];
        if (u == v) continue;
        add_edge(u, v);
    }

    hld.work(1);
    std::cin>>q;
    while (q--) {
        int u, v;
        std::cin >> u >> v;
        u = bel[u], v = bel[v];
        int f = hld.lca(u, v);
        int fa = hld.get_fa(f);
        val[f]--;
        val[fa]--;
        val[u]++;
        val[v]++;
    }
    

    dfs(1, 0);

    std::cout << sum << "\n";
}
int main() {
    ios::sync_with_stdio(false);
    cin.tie(nullptr);
    int t = 1;
    // std::cin>>t;
    while (t--) fc();
    return 0;
}